package com.cow.framework.utils.date;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

/**
 * 
 * 日期时间方法
 * 
 * @author yangsj
 * @since 2014-10-16
 * @version 1.0
 * 
 */
public class DateUtil {
	/**
	 * 缺省日期时间格式yyyy-MM-dd HH:mm:ss
	 */
	public static final String C_TIME_PATTON_DEFAULT = "yyyy-MM-dd HH:mm:ss";
	/**
	 * 缺省日期格式yyyy-MM-dd
	 */
	public static final String C_DATE_PATTON_DEFAULT = "yyyy-MM-dd";
	/**
	 * 日期格式yyyyMMdd
	 */
	public static final String C_DATA_PATTON_YYYYMMDD = "yyyyMMdd";
	/**
	 * 时间格式HH:mm:ss
	 */
	public static final String C_TIME_PATTON_HHMMSS = "HH:mm:ss";

	private static final int C_ONE_SECOND = 1000;
	private static final int C_ONE_MINUTE = 60 * C_ONE_SECOND;
	private static final int C_ONE_HOUR = 60 * C_ONE_MINUTE;
	@SuppressWarnings("unused")
	private static final long C_ONE_DAY = 24 * C_ONE_HOUR;

	/**
	 * 获取当前时间
	 * 
	 * @return DATE 当前时间
	 */
	public static Date getCurrentTime() {
		Calendar cal = Calendar.getInstance();
		Date currDate = cal.getTime();
		return currDate;
	}
	
	/**
	 * 获取当前时间
	 * 
	 * @return DATE 当前时间
	 */
	public static Date getCurrentDate() {
		return parseDate(getCurrentDateStr());
	}

	/**
	 * 获取当前日期字符串,按yyyy-MM-dd格式返回
	 * 
	 * @return String 当前日期字符串,按yyyy-MM-dd格式返回
	 */
	public static String getCurrentDateStr() {
		Calendar cal = Calendar.getInstance();
		Date currDate = cal.getTime();
		return format(currDate);
	}

	/**
	 * 获取当前时间字符串,按yyyy-MM-dd HH:mm:ss格式返回
	 * 
	 * @return String 获取当前时间字符串,按yyyy-MM-dd HH:mm:ss格式返回
	 */
	public static String getCurrentTimeStr() {
		Calendar cal = Calendar.getInstance();
		return formatTime(cal.getTime());
	}

	/**
	 * 获取当前时间字符串,按指定格式返回
	 * 
	 * @param strFormat
	 *            指定格式,例如yyyy-MM-dd HH:mm:ss
	 * @return String 当前时间字符串,按指定格式返回
	 */
	public static String getCurrentDateStr(String strFormat) {
		Calendar cal = Calendar.getInstance();
		Date currDate = cal.getTime();

		return format(currDate, strFormat);
	}

	/**
	 * 将格式为yyyy-MM-dd的字符串转为日期类型
	 * 
	 * @param dateValue
	 *            格式为yyyy-MM-dd日期字符串,串中的年月日时分秒值超过有效值时,会自动向前后推算成正确的时间<br>
	 *            格式不正确时，按JAVA内部机制处理，不保证转换正确<br>
	 * @return Date 转换后的日期
	 */
	public static Date parseDate(String dateValue) {
		return parseDate(C_DATE_PATTON_DEFAULT, dateValue);
	}

	/**
	 * 将格式为yyyy-MM-dd HH:mm:ss的字符串转为时间类型
	 * 
	 * @param dateValue
	 *            格式为yyyy-MM-dd HH:mm:ss的字符串,串中的年月日时分秒值超过有效值时,会自动向前后推算成正确的时间<br>
	 *            格式不正确时，按JAVA内部机制处理，不保证转换正确<br>
	 * @return Date 转换后的日期类型
	 */
	public static Date parseDateTime(String dateValue) {
		return parseDate(C_TIME_PATTON_DEFAULT, dateValue);
	}

	/**
	 * 将字符类型转为日期类型,转换失败返回null
	 * 
	 * @param strFormat
	 *            格式,为null则缺省按yyyy-MM-dd HH:mm:ss格式
	 * @param dateValue
	 *            按strFormat格式表示的日期时间字符串,串中的年月日时分秒值超过有效值时,会自动向前后推算成正确的时间<br>
	 *            格式不正确时，按JAVA内部机制处理，不保证转换正确<br>
	 * @return Date 转换后的日期类型
	 */
	public static Date parseDate(String strFormat, String dateValue) {
		if (dateValue == null)
			return null;

		if (strFormat == null)
			strFormat = C_TIME_PATTON_DEFAULT;

		SimpleDateFormat dateFormat = new SimpleDateFormat(strFormat);
		Date newDate = null;

		try {
			newDate = dateFormat.parse(dateValue);
		} catch (ParseException pe) {
			newDate = null;
		}

		return newDate;
	}

	/**
	 * 时间转换为日期字符串,格式为yyyy-MM-dd
	 * 
	 * @param aTs_Datetime
	 *            需要转换的时间。
	 * @return String 日期字符串,格式为yyyy-MM-dd
	 */
	public static String format(Date aTs_Datetime) {
		return format(aTs_Datetime, C_DATE_PATTON_DEFAULT);
	}

	/**
	 * 时间转换为时间字符串,格式为yyyy-MM-dd HH:mm:ss
	 * 
	 * @param aTs_Datetime
	 *            需要转换的时间。
	 * @return String 时间字符串,格式为yyyy-MM-dd HH:mm:ss
	 */
	public static String formatTime(Date aTs_Datetime) {
		return format(aTs_Datetime, C_TIME_PATTON_DEFAULT);
	}

	/**
	 * 时间转换为字符串，时分秒全为0按yyyy-MM-dd格式转换，否则按yyyy-MM-dd HH:mm:ss格式转换
	 * 
	 * @param aTs_Datetime
	 * @return String 时间转换为字符串，时分秒全为0按yyyy-MM-dd格式转换，否则按yyyy-MM-dd HH:mm:ss格式转换
	 */
	public static String autoFormat(Date aTs_Datetime) {
		if (format(aTs_Datetime, C_TIME_PATTON_DEFAULT).substring(11).equals("00:00:00")) {
			return format(aTs_Datetime, C_DATE_PATTON_DEFAULT);
		} else {
			return format(aTs_Datetime, C_TIME_PATTON_DEFAULT);
		}
	}

	/**
	 * 将Date类型 按指定格式转换为字符串，失败返回null
	 * 
	 * @param aTs_Datetime
	 *            需转换的日期时间
	 * @param as_Pattern
	 *            输出格式，例如yyyy-MM-dd HH:mm:ss
	 * @return String 将Date类型 按指定格式转换为字符串
	 */
	public static String format(Date aTs_Datetime, String as_Pattern) {
		if (aTs_Datetime == null || as_Pattern == null)
			return null;

		try {
			SimpleDateFormat dateFromat = new SimpleDateFormat();
			dateFromat.applyPattern(as_Pattern);

			return dateFromat.format(aTs_Datetime);
		} catch (Exception ex) {
			return null;
		}
	}

	/**
	 * 
	 * 将Date类型的时分秒转换为字符串,格式为HH:mm:ss
	 * 
	 * @param dateTime
	 *            时间
	 * @return String 将Date类型的时分秒转换为字符串,格式为HH:mm:ss
	 * 
	 */
	public static String getFormatTime(Date dateTime) {
		return format(dateTime, C_TIME_PATTON_HHMMSS);
	}

	/**
	 * 将Timestamp类型转换为指定格式字符串,失败返回null
	 * 
	 * @param aTs_Datetime
	 *            时间
	 * @param as_Pattern
	 *            格式字符串，例如yyyy-MM-dd HH:mm:ss
	 * @return String 转换为指定格式字符串
	 */
	public static String format(Timestamp aTs_Datetime, String as_Pattern) {
		if (aTs_Datetime == null || as_Pattern == null)
			return null;

		try {
			SimpleDateFormat dateFromat = new SimpleDateFormat();
			dateFromat.applyPattern(as_Pattern);

			return dateFromat.format(aTs_Datetime);
		} catch (Exception ex) {
			return null;
		}
	}

	/**
	 * 
	 * 取得指定日期N天后的日期,N为负数表示N天前的日期
	 * 
	 * @param date
	 *            指定日期
	 * @param days
	 *            天数N
	 * @return Date 取得指定日期N天后的日期,N为负数表示N天前的日期
	 * 
	 */
	public static Date addDays(Date date, int days) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);

		cal.add(Calendar.DAY_OF_MONTH, days);

		return cal.getTime();
	}

	/**
	 * 计算两个日期之间相差的天数(date2 - date1)
	 * 
	 * @param date1
	 *            起始日期
	 * @param date2
	 *            结束日期
	 * @return double 返回两个日期之间相差的天数(date2 - date1)
	 */
	public static double daysBetween(Date date1, Date date2) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date1);
		double time1 = cal.getTimeInMillis();
		cal.setTime(date2);
		double time2 = cal.getTimeInMillis();
		return (time2 - time1) / (1000 * 3600 * 24);
	}

	/**
	 * 获取时间的月份
	 * 
	 * @param nowDate
	 *            指定日期
	 * @return int 月份
	 */
	public static int getMonth(Date nowDate) {
		int re = 0;
		Calendar nowCalendar = Calendar.getInstance();
		nowCalendar.setTime(nowDate);

		re = nowCalendar.get(2) + 1;
		return re;
	}

	/**
	 * 获取时间的年份
	 * 
	 * @param nowDate
	 *            时间
	 * @return int 时间的年份
	 */
	public static int getYear(Date nowDate) {
		int re = 0;
		Calendar nowCalendar = Calendar.getInstance();
		nowCalendar.setTime(nowDate);
		re = nowCalendar.get(1);
		return re;
	}

	/**
	 * 获取时间的小时
	 * 
	 * @param nowDate
	 *            时间
	 * @return int 获取时间的小时
	 */
	public static int getHour(Date nowDate) {
		int re = 0;
		Calendar nowCalendar = Calendar.getInstance();
		nowCalendar.setTime(nowDate);
		re = nowCalendar.get(11);
		return re;
	}

	/**
	 * 获取时间是一周的第几天，周日是第1天
	 * 
	 * @param nowDate
	 *            时间
	 * @return int 是一周的第几天，周日是第1天
	 */
	public static int getDay0fWeek(Date nowDate) {
		int re = 0;
		Calendar nowCalendar = Calendar.getInstance();
		nowCalendar.setTime(nowDate);
		re = nowCalendar.get(7);
		return re;
	}
	/** 
    * start 
    * 本周开始时间戳 - 以星期一为本周的第一天 
    */ 
	public static Date getWeekStartDate(){
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY); 
		cal.set(Calendar.HOUR_OF_DAY, 0);
		cal.set(Calendar.MINUTE, 0);
		cal.set(Calendar.SECOND, 0);
		Date date = cal.getTime();
		return date;
	} 
	
	/** 
    * end 
    * 本周开始时间戳 - 以星期一为本周的第一天 
    */ 
	public static Date getWeekEndDate(){
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY); 
		cal.set(Calendar.HOUR_OF_DAY, 23);
		cal.set(Calendar.MINUTE, 59);
		cal.set(Calendar.SECOND, 59);
		cal.add(Calendar.WEEK_OF_YEAR, 1);
		Date date = cal.getTime();
		return date;
	} 
	
	/** 
	    * start 
	    * 上周开始时间戳 - 以星期一为一周的第一天 
	    */ 
		public static Date getLastWeekStartDate(){
			Calendar cal = Calendar.getInstance();
			int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK) - 1;
			int offset = 1 - dayOfWeek;
			cal.add(Calendar.DATE, offset - 7);
			cal.set(Calendar.HOUR_OF_DAY, 0);
			cal.set(Calendar.MINUTE, 0);
			cal.set(Calendar.SECOND, 0);
			Date date = cal.getTime();
			return date;
		} 
		
		/** 
	    * end 
	    * 上周结束时间戳 - 以星期一为一周的第一天 
	    */ 
		public static Date getLastWeekEndDate(){
			Calendar cal = Calendar.getInstance();
			int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK) - 1;
			int offset = 7 - dayOfWeek;  
			cal.add(Calendar.DATE, offset - 7);
			cal.set(Calendar.HOUR_OF_DAY, 23);
			cal.set(Calendar.MINUTE, 59);
			cal.set(Calendar.SECOND, 59);
			Date date = cal.getTime();
			return date;
		} 
	
	/** 获取本月第一天
	    */ 
		public static Date getMonthStartDate(){
			Calendar cal = Calendar.getInstance();
			cal.set(Calendar.DAY_OF_MONTH, 1); 
			cal.set(Calendar.HOUR_OF_DAY, 0);
			cal.set(Calendar.MINUTE, 0);
			cal.set(Calendar.SECOND, 0);
			Date date = cal.getTime();
			return date;
		} 
		
		/** 
	    * 获取本月最后一天 
	    */ 
		public static Date getMonthEndDate(){
			Calendar cal = Calendar.getInstance();
			cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); 
			cal.set(Calendar.HOUR_OF_DAY, 23);
			cal.set(Calendar.MINUTE, 59);
			cal.set(Calendar.SECOND, 59);
			Date date = cal.getTime();
			return date;
		} 
		
		/**
	     * 当前年的开始时间
	     * 
	     * @return
	     */
	    public  static Date getCurYearStartTime() {
	        Calendar c = Calendar.getInstance();
	        Date now = null;
	        try {
	            c.set(Calendar.MONTH, 0);
	            c.set(Calendar.DATE, 1);
	            return c.getTime();
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	        return now;
	    }

	    /**
	     * 当前年的结束时间
	     * 
	     * @return
	     */
	    public static Date getCurYearEndTime() {
	        Calendar c = Calendar.getInstance();
	        Date now = null;
	        try {
	            c.set(Calendar.MONTH, 11);
	            c.set(Calendar.DATE, 31);
	            c.set(Calendar.HOUR_OF_DAY, 23);
				c.set(Calendar.MINUTE, 59);
				c.set(Calendar.SECOND, 59);
	            return c.getTime();
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	        return now;
	    }

	    /**
	     * 当前季度的开始时间
	     * 
	     * @return
	     */
	    public static Date getCurQuarterStartTime() {
	        Calendar c = Calendar.getInstance();
	        int currentMonth = c.get(Calendar.MONTH) + 1;
	        Date now = null;
	        try {
	            if (currentMonth >= 1 && currentMonth <= 3)
	                c.set(Calendar.MONTH, 0);
	            else if (currentMonth >= 4 && currentMonth <= 6)
	                c.set(Calendar.MONTH, 3);
	            else if (currentMonth >= 7 && currentMonth <= 9)
	                c.set(Calendar.MONTH, 4);
	            else if (currentMonth >= 10 && currentMonth <= 12)
	                c.set(Calendar.MONTH, 9);
	            c.set(Calendar.DATE, 1);
	            return c.getTime();
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	        return now;
	    }

	    /**
	     * 当前季度的结束时间
	     * 
	     * @return
	     */
	    public static Date getCurQuarterEndTime() {
	        Calendar c = Calendar.getInstance();
	        int currentMonth = c.get(Calendar.MONTH) + 1;
	        Date now = null;
	        try {
	            if (currentMonth >= 1 && currentMonth <= 3) {
	                c.set(Calendar.MONTH, 2);
	                c.set(Calendar.DATE, 31);
	            } else if (currentMonth >= 4 && currentMonth <= 6) {
	                c.set(Calendar.MONTH, 5);
	                c.set(Calendar.DATE, 30);
	            } else if (currentMonth >= 7 && currentMonth <= 9) {
	                c.set(Calendar.MONTH, 8);
	                c.set(Calendar.DATE, 30);
	            } else if (currentMonth >= 10 && currentMonth <= 12) {
	                c.set(Calendar.MONTH, 11);
	                c.set(Calendar.DATE, 31);
	            }
	            
	            c.set(Calendar.HOUR_OF_DAY, 23);
				c.set(Calendar.MINUTE, 59);
				c.set(Calendar.SECOND, 59);
	            return c.getTime();
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	        return now;
	    }
	
    /** 
    * start 
    * 本周开始时间戳 - 以星期一为本周的第一天 
    */  
    public static String getWeekStartTime() {  
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat( "yyyyMMdd", Locale.getDefault());  
        Calendar cal = Calendar.getInstance();  
        int day_of_week = cal.get(Calendar. DAY_OF_WEEK) - 1;  
        if (day_of_week == 0 ) {  
            day_of_week = 7 ;  
        }  
        cal.add(Calendar.DATE , -day_of_week + 1 );  
        return simpleDateFormat.format(cal.getTime()) + "000000000";  
    }  
      
    /** 
    * end 
    * 本周结束时间戳 - 以星期一为本周的第一天 
    */  
    public static String getWeekEndTime() {  
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat( "yyyyMMdd", Locale.getDefault());  
        Calendar cal = Calendar.getInstance();  
        int day_of_week = cal.get(Calendar. DAY_OF_WEEK) - 1;  
        if (day_of_week == 0 ) {  
            day_of_week = 7 ;  
        }  
        cal.add(Calendar.DATE , -day_of_week + 7 );  
        return simpleDateFormat.format(cal.getTime()) + "235959999";  
    }  

	/**
	 * 获取时间，是一个月的第几天
	 * 
	 * @param nowDate
	 *            时间
	 * @return int 是一个月的第几天
	 */
	public static int getDay0fMonth(Date nowDate) {
		int re = 0;
		Calendar nowCalendar = Calendar.getInstance();
		nowCalendar.setTime(nowDate);
		re = nowCalendar.get(5);
		return re;
	}

	/**
	 * 将格式为yyyy-MM-dd HH:mm:ss的string 转换为date<br>
	 * 格式不正确时，按JAVA内部机制处理，不保证转换正确<br>
	 * @param textDate
	 *            格式为yyyy-MM-dd HH:mm:ss的时间字符串 ,串中的年月日时分秒值超过有效值时,会自动向前后推算成正确的时间
	 * @return Date 转换为date,失败时返回null
	 */
	public static Date getDate(String textDate) {
		SimpleDateFormat sdfInput = new SimpleDateFormat(C_TIME_PATTON_DEFAULT);
		Date date = null;
		try {
			date = sdfInput.parse(textDate);
		} catch (ParseException ex) {
		}
		return date;
	}

	/**
	 * 获取当天的0点整时刻值
	 * 
	 * @return Date 当天的0点整时刻值
	 */
	public static Date getDayStartTime() {
		SimpleDateFormat f = new SimpleDateFormat(C_DATE_PATTON_DEFAULT);

		Date currentTime2 = new Date();
		String endTimeString = f.format(currentTime2) + " 00:00:00";
		Date endTime = getDate(endTimeString);
		return endTime;
	}

	/**
	 * 获取当天的23:59:59时刻值
	 * 
	 * @return Date 当天的23:59:59时刻值
	 */
	public static Date getDayEndTime() {
		SimpleDateFormat f = new SimpleDateFormat(C_DATE_PATTON_DEFAULT);

		Date currentTime2 = new Date();
		String endTimeString = f.format(currentTime2) + " 23:59:59";
		Date endTime = getDate(endTimeString);
		return endTime;
	}

	/**
	 * 获取当天指定整点的时刻值,0<=hour<=23,否则返回null
	 * 
	 * @return Date 当天指定整点的时刻值
	 */
	public static Date toDayHour(int hour) {
		SimpleDateFormat f = new SimpleDateFormat(C_DATE_PATTON_DEFAULT);
		if (hour < 0 || 23 < hour)
			return null;
		Date currentTime2 = new Date();
		String endTimeString = f.format(currentTime2) + " " + hour + ":00:00";
		Date endTime = getDate(endTimeString);
		return endTime;
	}

	/**
	 * 获取格式为MM-dd的时间字符串
	 * 
	 * @param dateTime
	 *            时间
	 * @return String 获取格式为MM-dd的时间字符串
	 */
	public static String getShortDate(Date dateTime) {
		if (dateTime == null)
			return "";
		String time = formatTime(dateTime);
		return time.substring(5, 10);
	}

	/**
	 * 获取格式为MM-dd HH:mm的时间字符串
	 * 
	 * @param dateTime
	 *            时间
	 * @return String 获取格式为MM-dd HH:mm的时间字符串
	 */
	public static String getShortTime(Date dateTime) {
		if (dateTime == null)
			return "";
		String time = formatTime(dateTime);
		return time.substring(5, 16);
	}

	/**
	 * 返回两个日期之差的绝对值，格式为"X天X小时X分钟"
	 * 
	 * @param date1
	 *            起始时间
	 * @param date2
	 *            结束时间
	 * @return String 两个日期之差的绝对值，格式为"X天X小时X分钟"
	 */
	public static String timesBetween(Date date1, Date date2) {
		String re = "";
		long timeBetweenLong = Math.abs(date2.getTime() - date1.getTime());
		long dayTimeLong = timeBetweenLong / (24 * 60 * 60 * 1000);
		if (dayTimeLong > 0) {
			re = re + dayTimeLong + "天";
		}
		long hoursTimeLong = timeBetweenLong % (24 * 60 * 60 * 1000) / (60 * 60 * 1000);
		if (hoursTimeLong > 0) {
			re = re + hoursTimeLong + "小时";
		}

		long mTimeLong = timeBetweenLong % (24 * 60 * 60 * 1000) % (60 * 60 * 1000) / (60 * 1000);

		re = re + mTimeLong + "分钟";
		return re;

	}

	/**
	 * 按照指定格式获取系统当前时间,失败返回null
	 * 
	 * @param format
	 *            格式字符串, 例如yyyy-MM-dd HH:mm:ss
	 * @return String 系统当前时间字符串
	 */
	public static String sysdate(String format) {
		return format(new Date(), format);
	}

	/**
	 * 获取系统当前时间字符串, 格式为yyyy-MM-dd HH:mm:ss
	 * 
	 * @return String 当前时间字符串, 格式为yyyy-MM-dd HH:mm:ss
	 */
	public static String sysdate() {
		return sysdate(C_TIME_PATTON_DEFAULT);
	}

	/**
	 * 按照指定格式转换时间字符串
	 * 
	 * @param date
	 *            时间字符串,格式与format相同
	 * @param format
	 *            指定格式,例如yyyy-MM-dd HH:mm:ss
	 * @return Date 转换后的时间
	 */
	private static Date parse(String date, String format){
		SimpleDateFormat sf = new SimpleDateFormat(format);
		try {
			return sf.parse(date);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 按照指定格式转换时间字符串
	 * 
	 * @param date
	 *            时间字符串,格式与format相同
	 * @param format
	 *            指定格式,例如yyyy-MM-dd HH:mm:ss
	 * @return Date 转换后的时间
	 */
	private static Date parseTime(String dateTime) throws ParseException {
		SimpleDateFormat sf = new SimpleDateFormat(C_TIME_PATTON_DEFAULT);
		return sf.parse(dateTime);
	}

	/**
	 * 转换时间字符串为Date,字符串格式为yyyy-MM-dd
	 * 
	 * @param date
	 *            格式为yyyy-MM-dd的时间字符串,串中的年月日时分秒值超过有效值时,会自动向前后推算成正确的时间<br>
	 *            格式不正确时，按JAVA内部机制处理，不保证转换正确<br>
	 * @return Date 转换时间字符串为Date
	 */
	public static Date parse(String date) {
		return parse(date, C_DATE_PATTON_DEFAULT);
	}


	/**
	 * 获取当前月第一天的日期字符串，格式为yyyy-MM-01
	 * 
	 * @return String 获取当前月第一天的日期字符串，格式为yyyy-MM-01
	 */
	public static String firstDay() {
		String m = format(new Date(), "yyyy-MM");
		return m + "-01";
	}

	/**
	 * 获取当天日期字符串，格式为yyyy-MM-dd
	 * 
	 * @return String 获取当天日期字符串，格式为yyyy-MM-dd
	 */
	public static String today() {
		return format(new Date(), C_DATE_PATTON_DEFAULT);
	}

    /*** 
     * convert Date to cron ,eg.  "0 06 10 15 1 ? 2014" 
     * @param date  : 时间点 
     * @return 
     */  
    public static String getDateCron(Date  date){  
        String dateFormat="ss mm HH dd MM ? yyyy";  
        return format(date, dateFormat);  
    }
    
    
    //过去多少天开始时间
    public static String PastSevenStartDay(int days){
    	 String str = "";
         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
         Calendar lastDate = Calendar.getInstance();
         lastDate.add(Calendar.DATE, -days);//日期回滚7天
         str=sdf.format(lastDate.getTime())+ " 00:00:00";
         return str;
    }
    
  //过去多少天结束时间
    public static String PastSevenEndDay(int days) {
    	String str = "";
    	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    	Date date;
		try {
			date = sdf.parse(PastSevenStartDay(days));
			Calendar lastDate = Calendar.getInstance();
			lastDate.setTime(date);
			lastDate.add(Calendar.DATE, days-1);//日期回滚7天
			str=sdf.format(lastDate.getTime())+ " 23:59:59";
		} catch (ParseException e) {
			e.printStackTrace();
		}  
        return str;
    }
    
}
